{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp learner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learner\n",
    "\n",
    "> This contains fastai Learner extensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from tsai.imports import *\n",
    "from tsai.utils import random_shuffle\n",
    "from tsai.data.core import *\n",
    "from tsai.data.validation import *\n",
    "from tsai.models.all import *\n",
    "from tsai.inference import *\n",
    "from fastai.learner import * \n",
    "from fastai.vision.models.all import *\n",
    "from fastai.data.transforms import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def show_batch(self:Learner, **kwargs):\n",
    "    self.dls.show_batch(**kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# export\n",
    "@patch\n",
    "def remove_all_cbs(self:Learner, max_iters=10):\n",
    "    i = 0\n",
    "    while len(self.cbs) > 0 and i < max_iters:  \n",
    "        self.remove_cbs(self.cbs)\n",
    "        i += 1\n",
    "    if len(self.cbs) > 0: print(f'Learner still has {len(self.cbs)} callbacks: {self.cbs}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def one_batch(self:Learner, i, b): # this fixes a bug that will be managed in the next release of fastai\n",
    "    self.iter = i\n",
    "#     b_on_device = tuple( e.to(device=self.dls.device) for e in b if hasattr(e, \"to\")) if self.dls.device is not None else b\n",
    "    b_on_device = to_device(b, device=self.dls.device) if self.dls.device is not None else b\n",
    "    self._split(b_on_device)\n",
    "    self._with_events(self._do_one_batch, 'batch', CancelBatchException)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def save_all(self:Learner, path='export', dls_fname='dls', model_fname='model', learner_fname='learner', verbose=False):\n",
    "    path = Path(path)\n",
    "    if not os.path.exists(path): os.makedirs(path)\n",
    "\n",
    "    self.dls_type = self.dls.__class__.__name__\n",
    "    if self.dls_type == \"MixedDataLoaders\":\n",
    "        self.n_loaders = (len(self.dls.loaders), len(self.dls.loaders[0].loaders))\n",
    "        dls_fnames = []\n",
    "        for i,dl in enumerate(self.dls.loaders):\n",
    "            for j,l in enumerate(dl.loaders):\n",
    "                l = l.new(num_workers=1)\n",
    "                torch.save(l, path/f'{dls_fname}_{i}_{j}.pth')\n",
    "                dls_fnames.append(f'{dls_fname}_{i}_{j}.pth')\n",
    "    else:\n",
    "        dls_fnames = []\n",
    "        self.n_loaders = len(self.dls.loaders)\n",
    "        for i,dl in enumerate(self.dls):\n",
    "            dl = dl.new(num_workers=1)\n",
    "            torch.save(dl, path/f'{dls_fname}_{i}.pth')\n",
    "            dls_fnames.append(f'{dls_fname}_{i}.pth')\n",
    "\n",
    "    # Saves the model along with optimizer\n",
    "    self.model_dir = path\n",
    "    self.save(f'{model_fname}', with_opt=True)\n",
    "\n",
    "    # Export learn without the items and the optimizer state for inference\n",
    "    self.export(path/f'{learner_fname}.pkl')\n",
    "    \n",
    "    pv(f'Learner saved:', verbose)\n",
    "    pv(f\"path          = '{path}'\", verbose)\n",
    "    pv(f\"dls_fname     = '{dls_fnames}'\", verbose)\n",
    "    pv(f\"model_fname   = '{model_fname}.pth'\", verbose)\n",
    "    pv(f\"learner_fname = '{learner_fname}.pkl'\", verbose)\n",
    "    \n",
    "    \n",
    "def load_all(path='export', dls_fname='dls', model_fname='model', learner_fname='learner', device=None, pickle_module=pickle, verbose=False):\n",
    "\n",
    "    if isinstance(device, int): device = torch.device('cuda', device)\n",
    "    elif device is None: device = default_device()\n",
    "    if device == 'cpu': cpu = True\n",
    "    else: cpu = None\n",
    "\n",
    "    path = Path(path)\n",
    "    learn = load_learner(path/f'{learner_fname}.pkl', cpu=cpu, pickle_module=pickle_module)\n",
    "    learn.load(f'{model_fname}', with_opt=True, device=device)\n",
    "\n",
    "    \n",
    "    if learn.dls_type == \"MixedDataLoaders\":\n",
    "        dls_fnames = []\n",
    "        _dls = []\n",
    "        for i in range(learn.n_loaders[0]):\n",
    "            _dl = []\n",
    "            for j in range(learn.n_loaders[1]):\n",
    "                l = torch.load(path/f'{dls_fname}_{i}_{j}.pth', map_location=device, pickle_module=pickle_module)\n",
    "                l = l.new(num_workers=0)\n",
    "                l.to(device)\n",
    "                dls_fnames.append(f'{dls_fname}_{i}_{j}.pth')\n",
    "                _dl.append(l)\n",
    "            _dls.append(MixedDataLoader(*_dl, path=learn.dls.path, device=device, shuffle=l.shuffle))\n",
    "        learn.dls = MixedDataLoaders(*_dls, path=learn.dls.path, device=device)\n",
    "\n",
    "    else:\n",
    "        loaders = []\n",
    "        dls_fnames = []\n",
    "        for i in range(learn.n_loaders):\n",
    "            dl = torch.load(path/f'{dls_fname}_{i}.pth', map_location=device, pickle_module=pickle_module)\n",
    "            dl = dl.new(num_workers=0)\n",
    "            dl.to(device)\n",
    "            first(dl)\n",
    "            loaders.append(dl)\n",
    "            dls_fnames.append(f'{dls_fname}_{i}.pth')\n",
    "        learn.dls = type(learn.dls)(*loaders, path=learn.dls.path, device=device)\n",
    "\n",
    "\n",
    "    pv(f'Learner loaded:', verbose)\n",
    "    pv(f\"path          = '{path}'\", verbose)\n",
    "    pv(f\"dls_fname     = '{dls_fnames}'\", verbose)\n",
    "    pv(f\"model_fname   = '{model_fname}.pth'\", verbose)\n",
    "    pv(f\"learner_fname = '{learner_fname}.pkl'\", verbose)\n",
    "    return learn\n",
    "\n",
    "load_learner_all = load_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "@delegates(subplots)\n",
    "def plot_metrics(self: Recorder, nrows=None, ncols=None, figsize=None, final_losses=True, perc=.5, **kwargs):\n",
    "    n_values = len(self.recorder.values)\n",
    "    if n_values < 2: \n",
    "        print('not enough values to plot a chart')\n",
    "        return\n",
    "    metrics = np.stack(self.values)\n",
    "    n_metrics = metrics.shape[1]\n",
    "    names = self.metric_names[1:n_metrics+1]\n",
    "    if final_losses: \n",
    "        sel_idxs = int(round(n_values * perc))\n",
    "        if sel_idxs >= 2:\n",
    "            metrics = np.concatenate((metrics[:,:2], metrics), -1)\n",
    "            names = names[:2] + names\n",
    "        else: \n",
    "            final_losses = False\n",
    "    n = len(names) - 1 - final_losses\n",
    "    if nrows is None and ncols is None:\n",
    "        nrows = int(math.sqrt(n))\n",
    "        ncols = int(np.ceil(n / nrows))\n",
    "    elif nrows is None: nrows = int(np.ceil(n / ncols))\n",
    "    elif ncols is None: ncols = int(np.ceil(n / nrows))\n",
    "    figsize = figsize or (ncols * 6, nrows * 4)\n",
    "    fig, axs = subplots(nrows, ncols, figsize=figsize, **kwargs)\n",
    "    axs = [ax if i < n else ax.set_axis_off() for i, ax in enumerate(axs.flatten())][:n]\n",
    "    axs = ([axs[0]]*2 + [axs[1]]*2 + axs[2:]) if final_losses else ([axs[0]]*2 + axs[1:])\n",
    "    for i, (name, ax) in enumerate(zip(names, axs)):\n",
    "        if i in [0, 1]:\n",
    "            ax.plot(metrics[:, i], color='#1f77b4' if i == 0 else '#ff7f0e', label='valid' if i == 1 else 'train')\n",
    "            ax.set_title('losses')\n",
    "            ax.set_xlim(0, len(metrics)-1)\n",
    "        elif i in [2, 3] and final_losses:\n",
    "            ax.plot(np.arange(len(metrics) - sel_idxs, len(metrics)), metrics[-sel_idxs:, i], \n",
    "                    color='#1f77b4' if i == 2 else '#ff7f0e', label='valid' if i == 3 else 'train')\n",
    "            ax.set_title('final losses')\n",
    "            ax.set_xlim(len(metrics) - sel_idxs, len(metrics)-1)\n",
    "            # ax.set_xticks(np.arange(len(metrics) - sel_idxs, len(metrics)))\n",
    "        else:\n",
    "            ax.plot(metrics[:, i], color='#1f77b4' if i == 0 else '#ff7f0e', label='valid' if i > 0 else 'train')\n",
    "            ax.set_title(name if i >= 2 * (1 + final_losses) else 'losses')\n",
    "            ax.set_xlim(0, len(metrics)-1)\n",
    "        ax.legend(loc='best')\n",
    "        ax.grid(color='gainsboro', linewidth=.5)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "@patch\n",
    "@delegates(subplots)\n",
    "def plot_metrics(self: Learner, **kwargs):\n",
    "    self.recorder.plot_metrics(**kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "@delegates(subplots)\n",
    "def show_probas(self:Learner, figsize=(6,6), ds_idx=1, dl=None, one_batch=False, max_n=None, **kwargs):\n",
    "    recorder = copy(self.recorder) # This is to avoid loss of recorded values while generating preds\n",
    "    if one_batch: dl = self.dls.one_batch()\n",
    "    probas, targets = self.get_preds(ds_idx=ds_idx, dl=[dl] if dl is not None else None)\n",
    "    if probas.ndim == 2 and probas.min() < 0 or probas.max() > 1: probas = nn.Softmax(-1)(probas)\n",
    "    if not isinstance(targets[0].item(), Integral): return\n",
    "    targets = targets.flatten()\n",
    "    if max_n is not None:\n",
    "        idxs = np.random.choice(len(probas), max_n, False)\n",
    "        probas, targets = probas[idxs], targets[idxs]\n",
    "    fig = plt.figure(figsize=figsize, **kwargs)\n",
    "    classes = np.unique(targets)\n",
    "    nclasses = len(classes)\n",
    "    vals = np.linspace(.5, .5 + nclasses - 1, nclasses)[::-1]\n",
    "    plt.vlines(.5, min(vals) - 1, max(vals), color='black', linewidth=.5)\n",
    "    cm = plt.get_cmap('gist_rainbow')\n",
    "    color = [cm(1.* c/nclasses) for c in range(1, nclasses + 1)][::-1]\n",
    "    # class_probas = np.array([probas[i,t] for i,t in enumerate(targets)])\n",
    "    class_probas = np.array([probas[i][t] for i,t in enumerate(targets)])\n",
    "    for i, c in enumerate(classes):\n",
    "        plt.scatter(class_probas[targets == c] if nclasses > 2 or i > 0 else 1 - class_probas[targets == c],\n",
    "                    targets[targets == c] + .5 * (np.random.rand((targets == c).sum()) - .5), color=color[i], edgecolor='black', alpha=.2, s=100)\n",
    "        if nclasses > 2: plt.vlines((targets == c).float().mean(), i - .5, i + .5, color='r', linewidth=.5)\n",
    "    plt.hlines(vals, 0, 1)\n",
    "    plt.ylim(min(vals) - 1, max(vals))\n",
    "    plt.xlim(0,1)\n",
    "    plt.xticks(np.linspace(0,1,11), fontsize=12)\n",
    "    plt.yticks(classes, [self.dls.vocab[x] for x in classes], fontsize=12)\n",
    "    plt.title('Predicted proba per true class' if nclasses > 2 else 'Predicted class 1 proba per true class', fontsize=14)\n",
    "    plt.xlabel('Probability', fontsize=12)\n",
    "    plt.ylabel('True class', fontsize=12)\n",
    "    plt.grid(axis='x', color='gainsboro', linewidth=.2)\n",
    "    plt.show()\n",
    "    self.recorder = recorder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export \n",
    "all_archs = [FCN, FCNPlus, InceptionTime, InceptionTimePlus, InCoordTime, XCoordTime,\n",
    "           InceptionTimePlus17x17, InceptionTimePlus32x32, InceptionTimePlus47x47, InceptionTimePlus62x62,\n",
    "           InceptionTimeXLPlus, MultiInceptionTimePlus, MiniRocketClassifier, MiniRocketRegressor, \n",
    "           MiniRocketVotingClassifier, MiniRocketVotingRegressor, MiniRocketFeaturesPlus, MiniRocketPlus, MiniRocketHead,\n",
    "           InceptionRocketFeaturesPlus, InceptionRocketPlus, MLP, MultiInputNet, OmniScaleCNN, RNN, LSTM, GRU, RNNPlus, LSTMPlus, GRUPlus, \n",
    "           RNN_FCN, LSTM_FCN, GRU_FCN, MRNN_FCN, MLSTM_FCN, MGRU_FCN, ROCKET, RocketClassifier, RocketRegressor, ResCNNBlock, ResCNN, \n",
    "           ResNet, ResNetPlus, TCN, TSPerceiver, TST, TSTPlus, MultiTSTPlus, TSiTPlus, TSiT, \n",
    "           TabFusionTransformer, TSTabFusionTransformer, TabModel, TabTransformer, TransformerModel, XCM, XCMPlus, \n",
    "           xresnet1d18, xresnet1d34, xresnet1d50, xresnet1d101, xresnet1d152, xresnet1d18_deep,\n",
    "           xresnet1d34_deep, xresnet1d50_deep, xresnet1d18_deeper, xresnet1d34_deeper, xresnet1d50_deeper,\n",
    "           XResNet1dPlus, xresnet1d18plus, xresnet1d34plus, xresnet1d50plus, xresnet1d101plus,\n",
    "           xresnet1d152plus, xresnet1d18_deepplus, xresnet1d34_deepplus, xresnet1d50_deepplus,\n",
    "           xresnet1d18_deeperplus, xresnet1d34_deeperplus, xresnet1d50_deeperplus, XceptionTime, XceptionTimePlus\n",
    "           ]\n",
    "\n",
    "all_archs_names = [arch.__name__ for arch in all_archs]\n",
    "def get_arch(arch_name):\n",
    "    assert arch_name in all_archs_names, \"confirm the name of the architecture\"\n",
    "    idx = all_archs_names.index(arch_name)\n",
    "    return all_archs[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arch_name = 'InceptionTimePlus'\n",
    "test_eq(get_arch('InceptionTimePlus').__name__, arch_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@delegates(build_ts_model)\n",
    "def ts_learner(dls, arch=None, c_in=None, c_out=None, seq_len=None, d=None, splitter=trainable_params,\n",
    "               # learner args\n",
    "               loss_func=None, opt_func=Adam, lr=defaults.lr, cbs=None, metrics=None, path=None,\n",
    "               model_dir='models', wd=None, wd_bn_bias=False, train_bn=True, moms=(0.95,0.85,0.95),\n",
    "               # other model args\n",
    "               **kwargs):\n",
    "\n",
    "    if arch is None: arch = InceptionTimePlus\n",
    "    elif isinstance(arch, str): arch = get_arch(arch)\n",
    "    model = build_ts_model(arch, dls=dls, c_in=c_in, c_out=c_out, seq_len=seq_len, d=d, **kwargs)\n",
    "    try:\n",
    "        model[0], model[1]\n",
    "        subscriptable = True\n",
    "    except:\n",
    "        subscriptable = False\n",
    "    if subscriptable: splitter = ts_splitter\n",
    "    if loss_func is None:\n",
    "        if hasattr(dls, 'loss_func'): loss_func = dls.loss_func\n",
    "        elif hasattr(dls, 'train_ds') and hasattr(dls.train_ds, 'loss_func'): loss_func = dls.train_ds.loss_func\n",
    "        elif hasattr(dls, 'cat') and not dls.cat: loss_func = MSELossFlat()\n",
    "        \n",
    "    learn = Learner(dls=dls, model=model,\n",
    "                    loss_func=loss_func, opt_func=opt_func, lr=lr, cbs=cbs, metrics=metrics, path=path, splitter=splitter,\n",
    "                    model_dir=model_dir, wd=wd, wd_bn_bias=wd_bn_bias, train_bn=train_bn, moms=moms, )\n",
    "\n",
    "    # keep track of args for loggers\n",
    "    store_attr('arch', self=learn)\n",
    "\n",
    "    return learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@delegates(build_tsimage_model)\n",
    "def tsimage_learner(dls, arch=None, pretrained=False,\n",
    "               # learner args\n",
    "               loss_func=None, opt_func=Adam, lr=defaults.lr, cbs=None, metrics=None, path=None,\n",
    "               model_dir='models', wd=None, wd_bn_bias=False, train_bn=True, moms=(0.95,0.85,0.95),\n",
    "               # other model args\n",
    "               **kwargs):\n",
    "\n",
    "    if arch is None: arch = xresnet34\n",
    "    elif isinstance(arch, str): arch = get_arch(arch)\n",
    "    model = build_tsimage_model(arch, dls=dls, pretrained=pretrained, **kwargs)\n",
    "    learn = Learner(dls=dls, model=model,\n",
    "                    loss_func=loss_func, opt_func=opt_func, lr=lr, cbs=cbs, metrics=metrics, path=path,\n",
    "                    model_dir=model_dir, wd=wd, wd_bn_bias=wd_bn_bias, train_bn=train_bn, moms=moms)\n",
    "\n",
    "    # keep track of args for loggers\n",
    "    store_attr('arch', self=learn)\n",
    "\n",
    "    return learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def decoder(self:Learner, o): return L([self.dls.decodes(oi) for oi in o])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # old\n",
    "# @patch\n",
    "# @delegates(GatherPredsCallback.__init__)\n",
    "# def get_X_preds(self: Learner, X, y=None, bs=64, with_input=False, with_decoded=True, with_loss=False, **kwargs):\n",
    "#     if with_loss and y is None:\n",
    "#         print('cannot find loss as y=None')\n",
    "#         with_loss = False\n",
    "#     dl = self.dls.valid.new_dl(X, y=y)\n",
    "#     dl.bs = ifnone(bs, self.dls.bs)\n",
    "#     output = list(self.get_preds(dl=dl, with_input=with_input, with_decoded=with_decoded, with_loss=with_loss, reorder=False))\n",
    "#     if with_decoded and hasattr(self.dls, 'vocab'):\n",
    "#         output[2 + with_input] = L([self.dls.vocab[p] for p in output[2 + with_input]])\n",
    "#     return tuple(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "@patch\n",
    "def feature_importance(self:Learner, feature_names=None, key_metric_idx=0, show_chart=True, save_df_path=False, random_state=23):\n",
    "    r\"\"\"Calculates feature importance defined to be the change in a model validation loss or metric when a single feature value is randomly shuffled\n",
    "    \n",
    "    This procedure breaks the relationship between the feature and the target, thus the change in the model validation loss or metric is indicative of \n",
    "    how much the model depends on the feature.\n",
    "    \n",
    "    Args:\n",
    "        feature_names (Optional[list(str)]): list of feature names that will be displayed if available. Otherwise they will be var_0, var_1, etc.\n",
    "        key_metric_idx (Optional[int]): integer to select the metric used in the calculation. If None or no metric is available, \n",
    "                                        the change is calculated using the validation loss.\n",
    "        show_chart (bool): flag to indicate if a chart showing permutation feature importance will be plotted.\n",
    "        save_df_path (str): path to saved dataframe containing the permutation feature importance results.\n",
    "        random_state (int): controls the shuffling applied to the data. Pass an int for reproducible output across multiple function calls.\n",
    "    \"\"\"\n",
    "\n",
    "    X_valid = self.dls.valid.dataset.tls[0].items\n",
    "    y_valid = self.dls.valid.dataset.tls[1].items\n",
    "\n",
    "    metrics = [mn for mn in self.recorder.metric_names if mn not in ['epoch', 'train_loss', 'valid_loss', 'time']]\n",
    "    if len(metrics) == 0 or key_metric_idx is None: \n",
    "        metric_name = self.loss_func.__class__.__name__\n",
    "        key_metric_idx = None\n",
    "    else: \n",
    "        metric_name = metrics[key_metric_idx]\n",
    "        metric = self.recorder.metrics[key_metric_idx].func\n",
    "    print(f'Selected metric: {metric_name}')\n",
    "\n",
    "    # Adapted from https://www.kaggle.com/cdeotte/lstm-feature-importance by Chris Deotte (Kaggle GrandMaster)\n",
    "    if feature_names is None: \n",
    "        feature_names = [f\"var_{i}\" for i in range(X.shape[1])]\n",
    "\n",
    "    results = []\n",
    "    print('Computing feature importance...')\n",
    "\n",
    "    COLS = ['BASELINE'] + list(feature_names)\n",
    "    try: \n",
    "        for k in progress_bar(range(len(COLS))):\n",
    "            if k>0: \n",
    "                save_feat = X_valid[:, k-1].copy()\n",
    "                X_valid[:, k-1] = random_shuffle(X_valid[:, k-1].flatten(), random_state=random_state).reshape(X_valid[:, k-1].shape)\n",
    "            if key_metric_idx is None: \n",
    "                value = self.get_X_preds(X_valid, y_valid, with_loss=True)[-1].mean().item()\n",
    "            else: \n",
    "                output = self.get_X_preds(X_valid, y_valid)\n",
    "                value = metric(output[0], output[1]).item()\n",
    "            print(f\"{k:3} feature: {COLS[k]:20} {metric_name}: {value:8.6f}\")\n",
    "            results.append([COLS[k], value])\n",
    "            if k>0: \n",
    "                X_valid[:, k-1] = save_feat\n",
    "                del save_feat; gc.collect()\n",
    "    \n",
    "    except KeyboardInterrupt:\n",
    "        if k>0: \n",
    "            X_valid[:, k-1] = save_feat\n",
    "            del save_feat; gc.collect()\n",
    "        \n",
    "    # Display feature importance\n",
    "    if show_chart:\n",
    "        print()\n",
    "        df = pd.DataFrame(results, columns=[\"Feature\", metric_name])\n",
    "        df = df.sort_values(metric_name, ascending=key_metric_idx is None)\n",
    "        plt.figure(figsize=(10, .5*len(results)))\n",
    "        plt.barh(np.arange(len(results)), df[metric_name], color=\"darkblue\")\n",
    "        plt.yticks(np.arange(len(results)), df[\"Feature\"].values)\n",
    "        plt.title('Permutation Feature Importance', size=16)\n",
    "        plt.xlabel(f\"{metric_name}\")\n",
    "        plt.ylim((-1,len(results)))\n",
    "        plt.show()\n",
    "\n",
    "    # Save feature importance\n",
    "    if save_df_path:\n",
    "        df = df.sort_values(metric_name,ascending=False)\n",
    "        df.to_csv(f'{save_df_path}.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset: OliveOil\n",
      "X      : (60, 1, 570)\n",
      "y      : (60,)\n",
      "splits : (#30) [0,1,2,3,4,5,6,7,8,9...] (#30) [30,31,32,33,34,35,36,37,38,39...] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "from tsai.data.all import *\n",
    "from tsai.data.core import *\n",
    "from tsai.models.FCNPlus import *\n",
    "dsid = 'OliveOil'\n",
    "X, y, splits = get_UCR_data(dsid, verbose=True, split_data=False)\n",
    "tfms  = [None, [Categorize()]]\n",
    "dls = get_ts_dls(X, y, splits=splits, tfms=tfms)\n",
    "learn = ts_learner(dls, FCNPlus)\n",
    "for p in learn.model.parameters():\n",
    "    p.requires_grad=False\n",
    "test_eq(count_parameters(learn.model), 0)\n",
    "learn.freeze()\n",
    "test_eq(count_parameters(learn.model), 1540)\n",
    "learn.unfreeze()\n",
    "test_eq(count_parameters(learn.model), 264580)\n",
    "\n",
    "learn = ts_learner(dls, 'FCNPlus')\n",
    "for p in learn.model.parameters():\n",
    "    p.requires_grad=False\n",
    "test_eq(count_parameters(learn.model), 0)\n",
    "learn.freeze()\n",
    "test_eq(count_parameters(learn.model), 1540)\n",
    "learn.unfreeze()\n",
    "test_eq(count_parameters(learn.model), 264580)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x864 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.show_batch();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.310522</td>\n",
       "      <td>1.308359</td>\n",
       "      <td>0.300000</td>\n",
       "      <td>00:04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.308826</td>\n",
       "      <td>1.299902</td>\n",
       "      <td>0.400000</td>\n",
       "      <td>00:03</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dsid = 'OliveOil'\n",
    "X, y, splits = get_UCR_data(dsid, split_data=False)\n",
    "tfms  = [None, [TSClassification()]]\n",
    "dls = get_ts_dls(X, y, tfms=tfms, splits=splits)\n",
    "learn = ts_learner(dls, FCNPlus, metrics=accuracy)\n",
    "learn.fit_one_cycle(2)\n",
    "learn.plot_metrics()\n",
    "learn.show_probas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected metric: accuracy\n",
      "Computing feature importance...\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='2' class='' max='2' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [2/2 00:02<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0 feature: BASELINE             accuracy: 0.400000\n"
     ]
    },
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1 feature: var_0                accuracy: 0.400000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.feature_importance();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(\"./models\"): os.mkdir(\"./models\")\n",
    "if not os.path.exists(\"./data\"): os.mkdir(\"./data\")\n",
    "np.save(\"data/X_test.npy\", X[splits[1]])\n",
    "np.save(\"data/y_test.npy\", y[splits[1]])\n",
    "learn.export(\"./models/test.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.save_checkpoint();"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "052_learner.ipynb saved at 2021-11-29 20:22:27.\n",
      "Converted 052_learner.ipynb.\n",
      "\n",
      "\n",
      "Correct conversion! 😃\n",
      "Total time elapsed 0.121 s\n",
      "Monday 29/11/21 20:22:30 CET\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#hide\n",
    "from tsai.imports import create_scripts\n",
    "from tsai.export import get_nb_name\n",
    "nb_name = get_nb_name()\n",
    "create_scripts(nb_name);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
